{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Revisiting Lambert's problem in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib notebook\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from cycler import cycler\n",
    "\n",
    "from poliastro.iod import izzo\n",
    "\n",
    "plt.rc('text', usetex=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part 1: Reproducing the original figure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.linspace(-1, 2, num=1000)\n",
    "M_list = 0, 1, 2, 3\n",
    "ll_list = 1, 0.9, 0.7, 0, -0.7, -0.9, -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "window.mpl = {};\n",
       "\n",
       "mpl.get_websocket_type = function() {\n",
       "    if (typeof(WebSocket) !== 'undefined') {\n",
       "        return WebSocket;\n",
       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
       "        return MozWebSocket;\n",
       "    } else {\n",
       "        alert('Your browser does not have WebSocket support.' +\n",
       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
       "              'Firefox 4 and 5 are also supported but you ' +\n",
       "              'have to enable WebSockets in about:config.');\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
       "    this.id = figure_id;\n",
       "\n",
       "    this.ws = websocket;\n",
       "\n",
       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
       "\n",
       "    if (!this.supports_binary) {\n",
       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
       "        if (warnings) {\n",
       "            warnings.style.display = 'block';\n",
       "            warnings.textContent = (\n",
       "                \"This browser does not support binary websocket messages. \" +\n",
       "                    \"Performance may be slow.\");\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.imageObj = new Image();\n",
       "\n",
       "    this.context = undefined;\n",
       "    this.message = undefined;\n",
       "    this.canvas = undefined;\n",
       "    this.rubberband_canvas = undefined;\n",
       "    this.rubberband_context = undefined;\n",
       "    this.format_dropdown = undefined;\n",
       "\n",
       "    this.image_mode = 'full';\n",
       "\n",
       "    this.root = $('<div/>');\n",
       "    this._root_extra_style(this.root)\n",
       "    this.root.attr('style', 'display: inline-block');\n",
       "\n",
       "    $(parent_element).append(this.root);\n",
       "\n",
       "    this._init_header(this);\n",
       "    this._init_canvas(this);\n",
       "    this._init_toolbar(this);\n",
       "\n",
       "    var fig = this;\n",
       "\n",
       "    this.waiting = false;\n",
       "\n",
       "    this.ws.onopen =  function () {\n",
       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
       "            fig.send_message(\"send_image_mode\", {});\n",
       "            fig.send_message(\"refresh\", {});\n",
       "        }\n",
       "\n",
       "    this.imageObj.onload = function() {\n",
       "            if (fig.image_mode == 'full') {\n",
       "                // Full images could contain transparency (where diff images\n",
       "                // almost always do), so we need to clear the canvas so that\n",
       "                // there is no ghosting.\n",
       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
       "            }\n",
       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
       "        };\n",
       "\n",
       "    this.imageObj.onunload = function() {\n",
       "        this.ws.close();\n",
       "    }\n",
       "\n",
       "    this.ws.onmessage = this._make_on_message_function(this);\n",
       "\n",
       "    this.ondownload = ondownload;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_header = function() {\n",
       "    var titlebar = $(\n",
       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
       "        'ui-helper-clearfix\"/>');\n",
       "    var titletext = $(\n",
       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
       "        'text-align: center; padding: 3px;\"/>');\n",
       "    titlebar.append(titletext)\n",
       "    this.root.append(titlebar);\n",
       "    this.header = titletext[0];\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = $('<div/>');\n",
       "\n",
       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
       "\n",
       "    function canvas_keyboard_event(event) {\n",
       "        return fig.key_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
       "    this.canvas_div = canvas_div\n",
       "    this._canvas_extra_style(canvas_div)\n",
       "    this.root.append(canvas_div);\n",
       "\n",
       "    var canvas = $('<canvas/>');\n",
       "    canvas.addClass('mpl-canvas');\n",
       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
       "\n",
       "    this.canvas = canvas[0];\n",
       "    this.context = canvas[0].getContext(\"2d\");\n",
       "\n",
       "    var rubberband = $('<canvas/>');\n",
       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
       "\n",
       "    var pass_mouse_events = true;\n",
       "\n",
       "    canvas_div.resizable({\n",
       "        start: function(event, ui) {\n",
       "            pass_mouse_events = false;\n",
       "        },\n",
       "        resize: function(event, ui) {\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "        stop: function(event, ui) {\n",
       "            pass_mouse_events = true;\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "    });\n",
       "\n",
       "    function mouse_event_fn(event) {\n",
       "        if (pass_mouse_events)\n",
       "            return fig.mouse_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
       "\n",
       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
       "\n",
       "    canvas_div.on(\"wheel\", function (event) {\n",
       "        event = event.originalEvent;\n",
       "        event['data'] = 'scroll'\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        mouse_event_fn(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.append(canvas);\n",
       "    canvas_div.append(rubberband);\n",
       "\n",
       "    this.rubberband = rubberband;\n",
       "    this.rubberband_canvas = rubberband[0];\n",
       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
       "\n",
       "    this._resize_canvas = function(width, height) {\n",
       "        // Keep the size of the canvas, canvas container, and rubber band\n",
       "        // canvas in synch.\n",
       "        canvas_div.css('width', width)\n",
       "        canvas_div.css('height', height)\n",
       "\n",
       "        canvas.attr('width', width);\n",
       "        canvas.attr('height', height);\n",
       "\n",
       "        rubberband.attr('width', width);\n",
       "        rubberband.attr('height', height);\n",
       "    }\n",
       "\n",
       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
       "    // upon first draw.\n",
       "    this._resize_canvas(600, 600);\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
       "        return false;\n",
       "    });\n",
       "\n",
       "    function set_focus () {\n",
       "        canvas.focus();\n",
       "        canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    window.setTimeout(set_focus, 100);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            // put a spacer in here.\n",
       "            continue;\n",
       "        }\n",
       "        var button = $('<button/>');\n",
       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
       "                        'ui-button-icon-only');\n",
       "        button.attr('role', 'button');\n",
       "        button.attr('aria-disabled', 'false');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "\n",
       "        var icon_img = $('<span/>');\n",
       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
       "        icon_img.addClass(image);\n",
       "        icon_img.addClass('ui-corner-all');\n",
       "\n",
       "        var tooltip_span = $('<span/>');\n",
       "        tooltip_span.addClass('ui-button-text');\n",
       "        tooltip_span.html(tooltip);\n",
       "\n",
       "        button.append(icon_img);\n",
       "        button.append(tooltip_span);\n",
       "\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    var fmt_picker_span = $('<span/>');\n",
       "\n",
       "    var fmt_picker = $('<select/>');\n",
       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
       "    fmt_picker_span.append(fmt_picker);\n",
       "    nav_element.append(fmt_picker_span);\n",
       "    this.format_dropdown = fmt_picker[0];\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = $(\n",
       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
       "        fmt_picker.append(option)\n",
       "    }\n",
       "\n",
       "    // Add hover states to the ui-buttons\n",
       "    $( \".ui-button\" ).hover(\n",
       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
       "    );\n",
       "\n",
       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
       "    // which will in turn request a refresh of the image.\n",
       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_message = function(type, properties) {\n",
       "    properties['type'] = type;\n",
       "    properties['figure_id'] = this.id;\n",
       "    this.ws.send(JSON.stringify(properties));\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_draw_message = function() {\n",
       "    if (!this.waiting) {\n",
       "        this.waiting = true;\n",
       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
       "    }\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    var format_dropdown = fig.format_dropdown;\n",
       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
       "    fig.ondownload(fig, format);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
       "    var size = msg['size'];\n",
       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
       "        fig._resize_canvas(size[0], size[1]);\n",
       "        fig.send_message(\"refresh\", {});\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
       "    var x0 = msg['x0'];\n",
       "    var y0 = fig.canvas.height - msg['y0'];\n",
       "    var x1 = msg['x1'];\n",
       "    var y1 = fig.canvas.height - msg['y1'];\n",
       "    x0 = Math.floor(x0) + 0.5;\n",
       "    y0 = Math.floor(y0) + 0.5;\n",
       "    x1 = Math.floor(x1) + 0.5;\n",
       "    y1 = Math.floor(y1) + 0.5;\n",
       "    var min_x = Math.min(x0, x1);\n",
       "    var min_y = Math.min(y0, y1);\n",
       "    var width = Math.abs(x1 - x0);\n",
       "    var height = Math.abs(y1 - y0);\n",
       "\n",
       "    fig.rubberband_context.clearRect(\n",
       "        0, 0, fig.canvas.width, fig.canvas.height);\n",
       "\n",
       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
       "    // Updates the figure title.\n",
       "    fig.header.textContent = msg['label'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
       "    var cursor = msg['cursor'];\n",
       "    switch(cursor)\n",
       "    {\n",
       "    case 0:\n",
       "        cursor = 'pointer';\n",
       "        break;\n",
       "    case 1:\n",
       "        cursor = 'default';\n",
       "        break;\n",
       "    case 2:\n",
       "        cursor = 'crosshair';\n",
       "        break;\n",
       "    case 3:\n",
       "        cursor = 'move';\n",
       "        break;\n",
       "    }\n",
       "    fig.rubberband_canvas.style.cursor = cursor;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
       "    fig.message.textContent = msg['message'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
       "    // Request the server to send over a new figure.\n",
       "    fig.send_draw_message();\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
       "    fig.image_mode = msg['mode'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Called whenever the canvas gets updated.\n",
       "    this.send_message(\"ack\", {});\n",
       "}\n",
       "\n",
       "// A function to construct a web socket function for onmessage handling.\n",
       "// Called in the figure constructor.\n",
       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
       "    return function socket_on_message(evt) {\n",
       "        if (evt.data instanceof Blob) {\n",
       "            /* FIXME: We get \"Resource interpreted as Image but\n",
       "             * transferred with MIME type text/plain:\" errors on\n",
       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
       "             * to be part of the websocket stream */\n",
       "            evt.data.type = \"image/png\";\n",
       "\n",
       "            /* Free the memory for the previous frames */\n",
       "            if (fig.imageObj.src) {\n",
       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
       "                    fig.imageObj.src);\n",
       "            }\n",
       "\n",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data);\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
       "            fig.imageObj.src = evt.data;\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        var msg = JSON.parse(evt.data);\n",
       "        var msg_type = msg['type'];\n",
       "\n",
       "        // Call the  \"handle_{type}\" callback, which takes\n",
       "        // the figure and JSON message as its only arguments.\n",
       "        try {\n",
       "            var callback = fig[\"handle_\" + msg_type];\n",
       "        } catch (e) {\n",
       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        if (callback) {\n",
       "            try {\n",
       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
       "                callback(fig, msg);\n",
       "            } catch (e) {\n",
       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "}\n",
       "\n",
       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
       "mpl.findpos = function(e) {\n",
       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
       "    var targ;\n",
       "    if (!e)\n",
       "        e = window.event;\n",
       "    if (e.target)\n",
       "        targ = e.target;\n",
       "    else if (e.srcElement)\n",
       "        targ = e.srcElement;\n",
       "    if (targ.nodeType == 3) // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "\n",
       "    // jQuery normalizes the pageX and pageY\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    // offset() returns the position of the element relative to the document\n",
       "    var x = e.pageX - $(targ).offset().left;\n",
       "    var y = e.pageY - $(targ).offset().top;\n",
       "\n",
       "    return {\"x\": x, \"y\": y};\n",
       "};\n",
       "\n",
       "/*\n",
       " * return a copy of an object with only non-object keys\n",
       " * we need this to avoid circular references\n",
       " * http://stackoverflow.com/a/24161582/3208463\n",
       " */\n",
       "function simpleKeys (original) {\n",
       "  return Object.keys(original).reduce(function (obj, key) {\n",
       "    if (typeof original[key] !== 'object')\n",
       "        obj[key] = original[key]\n",
       "    return obj;\n",
       "  }, {});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
       "    var canvas_pos = mpl.findpos(event)\n",
       "\n",
       "    if (name === 'button_press')\n",
       "    {\n",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x;\n",
       "    var y = canvas_pos.y;\n",
       "\n",
       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
       "                             step: event.step,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "\n",
       "    /* This prevents the web browser from automatically changing to\n",
       "     * the text insertion cursor when the button is pressed.  We want\n",
       "     * to control all of the cursor setting manually through the\n",
       "     * 'cursor' event from matplotlib */\n",
       "    event.preventDefault();\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    // Handle any extra behaviour associated with a key event\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.key_event = function(event, name) {\n",
       "\n",
       "    // Prevent repeat events\n",
       "    if (name == 'key_press')\n",
       "    {\n",
       "        if (event.which === this._key)\n",
       "            return;\n",
       "        else\n",
       "            this._key = event.which;\n",
       "    }\n",
       "    if (name == 'key_release')\n",
       "        this._key = null;\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which != 17)\n",
       "        value += \"ctrl+\";\n",
       "    if (event.altKey && event.which != 18)\n",
       "        value += \"alt+\";\n",
       "    if (event.shiftKey && event.which != 16)\n",
       "        value += \"shift+\";\n",
       "\n",
       "    value += 'k';\n",
       "    value += event.which.toString();\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, {key: value,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
       "    if (name == 'download') {\n",
       "        this.handle_save(this, null);\n",
       "    } else {\n",
       "        this.send_message(\"toolbar_button\", {name: name});\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
       "    this.message.textContent = tooltip;\n",
       "};\n",
       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to  previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\"];\n",
       "\n",
       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
       "    // object with the appropriate methods. Currently this is a non binary\n",
       "    // socket, so there is still some room for performance tuning.\n",
       "    var ws = {};\n",
       "\n",
       "    ws.close = function() {\n",
       "        comm.close()\n",
       "    };\n",
       "    ws.send = function(m) {\n",
       "        //console.log('sending', m);\n",
       "        comm.send(m);\n",
       "    };\n",
       "    // Register the callback with on_msg.\n",
       "    comm.on_msg(function(msg) {\n",
       "        //console.log('receiving', msg['content']['data'], msg);\n",
       "        // Pass the mpl event to the overriden (by mpl) onmessage function.\n",
       "        ws.onmessage(msg['content']['data'])\n",
       "    });\n",
       "    return ws;\n",
       "}\n",
       "\n",
       "mpl.mpl_figure_comm = function(comm, msg) {\n",
       "    // This is the function which gets called when the mpl process\n",
       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
       "\n",
       "    var id = msg.content.data.id;\n",
       "    // Get hold of the div created by the display call when the Comm\n",
       "    // socket was opened in Python.\n",
       "    var element = $(\"#\" + id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm)\n",
       "\n",
       "    function ondownload(figure, format) {\n",
       "        window.open(figure.imageObj.src);\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy,\n",
       "                           ondownload,\n",
       "                           element.get(0));\n",
       "\n",
       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
       "    // web socket which is closed, not our websocket->open comm proxy.\n",
       "    ws_proxy.onopen();\n",
       "\n",
       "    fig.parent_element = element.get(0);\n",
       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
       "    if (!fig.cell_info) {\n",
       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
       "        return;\n",
       "    }\n",
       "\n",
       "    var output_index = fig.cell_info[2]\n",
       "    var cell = fig.cell_info[0];\n",
       "\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
       "    fig.root.unbind('remove')\n",
       "\n",
       "    // Update the output cell to use the data from the current canvas.\n",
       "    fig.push_to_output();\n",
       "    var dataURL = fig.canvas.toDataURL();\n",
       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
       "    // the notebook keyboard shortcuts fail.\n",
       "    IPython.keyboard_manager.enable()\n",
       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\">');\n",
       "    fig.close_ws(fig, msg);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
       "    fig.send_message('closing', msg);\n",
       "    // fig.ws.close()\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
       "    // Turn the data on the canvas into data in the output cell.\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\">';\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Tell IPython that the notebook contents must change.\n",
       "    IPython.notebook.set_dirty(true);\n",
       "    this.send_message(\"ack\", {});\n",
       "    var fig = this;\n",
       "    // Wait a second, then push the new image to the DOM so\n",
       "    // that it is saved nicely (might be nice to debounce this).\n",
       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items){\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) { continue; };\n",
       "\n",
       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
       "    buttongrp.append(button);\n",
       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
       "    titlebar.prepend(buttongrp);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(el){\n",
       "    var fig = this\n",
       "    el.on(\"remove\", function(){\n",
       "\tfig.close_ws(fig, {});\n",
       "    });\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
       "    // this is important to make the div 'focusable\n",
       "    el.attr('tabindex', 0)\n",
       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
       "    // off when our div gets focus\n",
       "\n",
       "    // location in version 3\n",
       "    if (IPython.notebook.keyboard_manager) {\n",
       "        IPython.notebook.keyboard_manager.register_events(el);\n",
       "    }\n",
       "    else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    var manager = IPython.notebook.keyboard_manager;\n",
       "    if (!manager)\n",
       "        manager = IPython.keyboard_manager;\n",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which == 13) {\n",
       "        this.canvas_div.blur();\n",
       "        event.shiftKey = false;\n",
       "        // Send a \"J\" for go to next cell\n",
       "        event.which = 74;\n",
       "        event.keyCode = 74;\n",
       "        manager.command_mode();\n",
       "        manager.handle_keydown(event);\n",
       "    }\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    fig.ondownload(fig, null);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.find_output_cell = function(html_output) {\n",
       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
       "    // IPython event is triggered only after the cells have been serialised, which for\n",
       "    // our purposes (turning an active figure into a static one), is too late.\n",
       "    var cells = IPython.notebook.get_cells();\n",
       "    var ncells = cells.length;\n",
       "    for (var i=0; i<ncells; i++) {\n",
       "        var cell = cells[i];\n",
       "        if (cell.cell_type === 'code'){\n",
       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
       "                var data = cell.output_area.outputs[j];\n",
       "                if (data.data) {\n",
       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
       "                    data = data.data;\n",
       "                }\n",
       "                if (data['text/html'] == html_output) {\n",
       "                    return [cell, data, j];\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "}\n",
       "\n",
       "// Register the function which deals with the matplotlib target/channel.\n",
       "// The kernel may be null if the page has been refreshed.\n",
       "if (IPython.notebook.kernel != null) {\n",
       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<img src=\"data:image/png;base64,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\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.text.Text at 0x7fc103fa4780>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(8, 6))\n",
    "ax.set_prop_cycle(cycler('linestyle', ['-', '--']) *\n",
    "                  (cycler('color', ['black']) * len(ll_list)))\n",
    "for M in M_list:\n",
    "    for ll in ll_list:\n",
    "        T_x0 = np.zeros_like(x)\n",
    "        for ii in range(len(x)):\n",
    "            y = izzo._compute_y(x[ii], ll)\n",
    "            T_x0[ii] = izzo._tof_equation(x[ii], y, 0.0, ll, M)\n",
    "        if M == 0 and ll == 1:\n",
    "            T_x0[x > 0] = np.nan\n",
    "        elif M > 0:\n",
    "            # Mask meaningless solutions\n",
    "            T_x0[x > 1] = np.nan\n",
    "        l, = ax.plot(x, T_x0)\n",
    "\n",
    "ax.set_ylim(0, 10)\n",
    "\n",
    "ax.set_xticks((-1, 0, 1, 2))\n",
    "ax.set_yticks((0, np.pi, 2 * np.pi, 3 * np.pi))\n",
    "ax.set_yticklabels(('$0$', '$\\pi$', '$2 \\pi$', '$3 \\pi$'))\n",
    "\n",
    "ax.vlines(1, 0, 10)\n",
    "ax.text(0.65, 4.0, \"elliptic\")\n",
    "ax.text(1.16, 4.0, \"hyperbolic\")\n",
    "\n",
    "ax.text(0.05, 1.5, \"$M = 0$\", bbox=dict(facecolor='white'))\n",
    "ax.text(0.05, 5, \"$M = 1$\", bbox=dict(facecolor='white'))\n",
    "ax.text(0.05, 8, \"$M = 2$\", bbox=dict(facecolor='white'))\n",
    "\n",
    "ax.annotate(\"$\\lambda = 1$\", xy=(-0.3, 1), xytext=(-0.75, 0.25), arrowprops=dict(arrowstyle=\"simple\", facecolor=\"black\"))\n",
    "ax.annotate(\"$\\lambda = -1$\", xy=(0.3, 2.5), xytext=(0.65, 2.75), arrowprops=dict(arrowstyle=\"simple\", facecolor=\"black\"))\n",
    "\n",
    "ax.grid()\n",
    "ax.set_xlabel(\"$x$\")\n",
    "ax.set_ylabel(\"$T$\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part 2: Locating $T_{min}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "for M in M_list:\n",
    "    for ll in ll_list:\n",
    "        x_T_min, T_min = izzo._compute_T_min(ll, M, 10, 1e-8)\n",
    "        ax.plot(x_T_min, T_min, 'kx', mew=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part 3: Try out solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.43344673453504257"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "T_ref = 1\n",
    "ll_ref = 0\n",
    "\n",
    "(x_ref, _), = izzo._find_xy(ll_ref, T_ref, 0, 10, 1e-8)\n",
    "x_ref"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7fc103f61748>]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ax.plot(x_ref, T_ref, 'o', mew=2, mec='red', mfc='none')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part 4: Run some examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from astropy import units as u\n",
    "\n",
    "from poliastro.bodies import Earth"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Single revolution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$[-3.4515641,~0.91031477,~0] \\; \\mathrm{\\frac{km}{s}}$"
      ],
      "text/plain": [
       "<Quantity [-3.45156412, 0.91031477, 0.        ] km / s>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k = Earth.k\n",
    "r0 = [15945.34, 0.0, 0.0] * u.km\n",
    "r = [12214.83399, 10249.46731, 0.0] * u.km\n",
    "tof = 76.0 * u.min\n",
    "\n",
    "expected_va = [2.058925, 2.915956, 0.0] * u.km / u.s\n",
    "expected_vb = [-3.451569, 0.910301, 0.0] * u.km / u.s\n",
    "\n",
    "(v0, v), = izzo.lambert(k, r0, r, tof)\n",
    "v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$[-3.3124603,~-4.1966173,~-0.38528762] \\; \\mathrm{\\frac{km}{s}}$"
      ],
      "text/plain": [
       "<Quantity [-3.31246031,-4.19661731,-0.38528762] km / s>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k = Earth.k\n",
    "r0 = [5000.0, 10000.0, 2100.0] * u.km\n",
    "r = [-14600.0, 2500.0, 7000.0] * u.km\n",
    "tof = 1.0 * u.h\n",
    "\n",
    "expected_va = [-5.9925, 1.9254, 3.2456] * u.km / u.s\n",
    "expected_vb = [-3.3125, -4.1966, -0.38529] * u.km / u.s\n",
    "\n",
    "(v0, v), = izzo.lambert(k, r0, r, tof)\n",
    "v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Multiple revolutions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "k = Earth.k\n",
    "r0 = [22592.145603, -1599.915239, -19783.950506] * u.km\n",
    "r = [1922.067697, 4054.157051, -8925.727465] * u.km\n",
    "tof = 10 * u.h\n",
    "\n",
    "expected_va = [2.000652697, 0.387688615, -2.666947760] * u.km / u.s\n",
    "expected_vb = [-3.79246619, -1.77707641, 6.856814395] * u.km / u.s\n",
    "\n",
    "expected_va_l = [0.50335770, 0.61869408, -1.57176904] * u.km / u.s\n",
    "expected_vb_l = [-4.18334626, -1.13262727, 6.13307091] * u.km / u.s\n",
    "\n",
    "expected_va_r = [-2.45759553, 1.16945801, 0.43161258] * u.km / u.s\n",
    "expected_vb_r = [-5.53841370, 0.01822220, 5.49641054] * u.km / u.s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$[-3.7924642,~-1.7770752,~6.8568103] \\; \\mathrm{\\frac{km}{s}}$"
      ],
      "text/plain": [
       "<Quantity [-3.7924642 ,-1.77707516, 6.85681026] km / s>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(v0, v), = izzo.lambert(k, r0, r, tof, M=0)\n",
    "v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "(_, v_l), (_, v_r) = izzo.lambert(k, r0, r, tof, M=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$[-4.1833446,~-1.1326259,~6.1330668] \\; \\mathrm{\\frac{km}{s}}$"
      ],
      "text/plain": [
       "<Quantity [-4.18334456,-1.13262586, 6.13306676] km / s>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v_l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$[-5.5384092,~0.018221573,~5.4964072] \\; \\mathrm{\\frac{km}{s}}$"
      ],
      "text/plain": [
       "<Quantity [-5.53840923, 0.01822157, 5.49640718] km / s>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v_r"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
